home *** CD-ROM | disk | FTP | other *** search
/ Workbench Add-On / Workbench Add-On - Volume 1.iso / BBS-Archive / Comm / AmiTCP30b2.lha / src / amitcp / netinet / tcp_input.c < prev    next >
C/C++ Source or Header  |  1994-03-26  |  45KB  |  1,580 lines
  1. RCS_ID_C="$Id: tcp_input.c,v 3.1 1994/03/26 09:53:54 too Exp $";
  2. /*
  3.  * Copyright (c) 1993 AmiTCP/IP Group, <amitcp-group@hut.fi>,
  4.  *                    Helsinki University of Technology, Finland.
  5.  *                    All rights reserved.
  6.  *
  7.  * HISTORY
  8.  * $Log: tcp_input.c,v $
  9.  * Revision 3.1  1994/03/26  09:53:54  too
  10.  * Added a call to `controlaccess()' before accepting incoming connection.
  11.  *
  12.  * Revision 1.12  1993/06/04  11:16:15  jraja
  13.  * Fixes for first public release.
  14.  *
  15.  * Revision 1.11  1993/05/17  00:16:44  ppessi
  16.  * Changed RCS version. Added rcsid.
  17.  *
  18.  * Revision 1.10  1993/04/24  17:45:38  jraja
  19.  * Changed MCLBYTES to mbconf.mclbytes. Removed compile time check for MCLBYTES
  20.  * since it is not worth to be done at run time.
  21.  *
  22.  * Revision 1.9  93/04/13  22:14:29  22:14:29  jraja (Jarno Tapio Rajahalme)
  23.  * Removed casts added earlier, because SAS did not like them :-(
  24.  * 
  25.  * Revision 1.8  93/04/11  22:26:51  22:26:51  jraja (Jarno Tapio Rajahalme)
  26.  * Added STKARGFUN to protocol input & output functions (if used in protosw).
  27.  * 
  28.  * Revision 1.7  93/04/05  19:06:27  19:06:27  jraja (Jarno Tapio Rajahalme)
  29.  * Changed storage of the spl functions  return values to type spl_t.
  30.  * Added include for conf.h to every .c file.
  31.  * 
  32.  * Revision 1.6  93/03/22  16:59:36  16:59:36  jraja (Jarno Tapio Rajahalme)
  33.  * Changed bcopy()s and bzero()s with word aligned pointers to
  34.  * aligned_b(copy|zero) ar aligned_b(copy|zero)_const. The latter is for calls
  35.  * in which the size is constant.
  36.  * These can be disabled by defining NOALIGN.
  37.  *  Converted bcopys doing structure copies (on aligned pointers) to structure
  38.  * assignments, since at least SASC produces better code with assignment.
  39.  * 
  40.  * Revision 1.5  93/03/13  17:14:24  17:14:24  ppessi (Pekka Pessi)
  41.  * Fixed bugs with variable initialization.
  42.  * 
  43.  * Revision 1.4  93/03/05  21:09:39  21:09:39  jraja (Jarno Tapio Rajahalme)
  44.  * Fixed includes (again).
  45.  * 
  46.  * Revision 1.3  93/03/05  03:20:15  03:20:15  ppessi (Pekka Pessi)
  47.  * Compiles with SASC. Initial test version.
  48.  * 
  49.  * Revision 1.2  93/02/26  09:43:56  09:43:56  jraja (Jarno Tapio Rajahalme)
  50.  * Made this compile with ANSI C (added prototypes).
  51.  * Added initialization of ostate in function tcp_input() because it might have
  52.  * been used without initialization.
  53.  * Casted  ti->ti_len to u_short in comparison with tp->rcv_wnd.
  54.  * Added explicit ()' around && in || in function tcp_input().
  55.  * 
  56.  * Revision 1.1  92/11/17  16:30:32  16:30:32  jraja (Jarno Tapio Rajahalme)
  57.  * Initial revision
  58.  *
  59.  */
  60.  
  61. /*
  62.  * Copyright (c) 1982, 1986, 1988, 1990 Regents of the University of California.
  63.  * All rights reserved.
  64.  *
  65.  * Redistribution and use in source and binary forms, with or without
  66.  * modification, are permitted provided that the following conditions
  67.  * are met:
  68.  * 1. Redistributions of source code must retain the above copyright
  69.  *    notice, this list of conditions and the following disclaimer.
  70.  * 2. Redistributions in binary form must reproduce the above copyright
  71.  *    notice, this list of conditions and the following disclaimer in the
  72.  *    documentation and/or other materials provided with the distribution.
  73.  * 3. All advertising materials mentioning features or use of this software
  74.  *    must display the following acknowledgement:
  75.  *    This product includes software developed by the University of
  76.  *    California, Berkeley and its contributors.
  77.  * 4. Neither the name of the University nor the names of its contributors
  78.  *    may be used to endorse or promote products derived from this software
  79.  *    without specific prior written permission.
  80.  *
  81.  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  82.  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  83.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  84.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  85.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  86.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  87.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  88.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  89.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  90.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  91.  * SUCH DAMAGE.
  92.  *
  93.  *    @(#)tcp_input.c    7.25 (Berkeley) 6/30/90
  94.  */
  95.  
  96. #include <conf.h>
  97.  
  98. #include <sys/param.h>
  99. #include <sys/systm.h>
  100. #include <sys/malloc.h>
  101. #include <sys/mbuf.h>
  102. #include <sys/protosw.h>
  103. #include <sys/socket.h>
  104. #include <sys/socketvar.h>
  105. #include <sys/errno.h>
  106.  
  107. #include <net/if.h>
  108. #include <net/route.h>
  109.  
  110. #include <netinet/in.h>
  111. #include <netinet/in_systm.h>
  112. #include <netinet/ip.h>
  113. #include <netinet/in_pcb.h>
  114. #include <netinet/ip_var.h>
  115. #include <netinet/tcp.h>
  116. #include <netinet/tcp_fsm.h>
  117. #include <netinet/tcp_seq.h>
  118. #include <netinet/tcp_timer.h>
  119. #include <netinet/tcp_var.h>
  120. #include <netinet/tcpip.h>
  121. #include <netinet/tcp_debug.h>
  122.  
  123. #include <netinet/tcp_input_protos.h>
  124. #include <netinet/tcp_output_protos.h>
  125. #include <netinet/tcp_subr_protos.h>
  126. #include <netinet/tcp_timer_protos.h>
  127. #include <netinet/tcp_debug_protos.h>
  128. #include <netinet/ip_input_protos.h>
  129. #include <netinet/in_pcb_protos.h>
  130. #include <netinet/in_protos.h>
  131. #include <netinet/in_cksum_protos.h>
  132. #include <kern/uipc_socket_protos.h>
  133. #include <kern/uipc_socket2_protos.h>
  134. #include <kern/accesscontrol.h>
  135.  
  136. int    tcprexmtthresh = 3;
  137. int    tcppredack = 0;    /* XXX debugging: times hdr predict ok for acks */
  138. int    tcppreddat = 0;    /* XXX # times header prediction ok for data packets */
  139. int    tcppcbcachemiss = 0;
  140. struct    tcpiphdr tcp_saveti = {0};
  141. struct    inpcb *tcp_last_inpcb = &tcb;
  142.  
  143. struct    tcpcb *tcp_newtcpcb();
  144.  
  145. /*
  146.  * Insert segment ti into reassembly queue of tcp with
  147.  * control block tp.  Return TH_FIN if reassembly now includes
  148.  * a segment with FIN.  The macro form does the common case inline
  149.  * (segment is the next to be received on an established connection,
  150.  * and the queue is empty), avoiding linkage into and removal
  151.  * from the queue and repetition of various conversions.
  152.  * Set DELACK for segments received in order, but ack immediately
  153.  * when segments are out of order (so fast retransmit can work).
  154.  */
  155. #define    TCP_REASS(tp, ti, m, so, flags) { \
  156.     if ((ti)->ti_seq == (tp)->rcv_nxt && \
  157.         (tp)->seg_next == (struct tcpiphdr *)(tp) && \
  158.         (tp)->t_state == TCPS_ESTABLISHED) { \
  159.         tp->t_flags |= TF_DELACK; \
  160.         (tp)->rcv_nxt += (ti)->ti_len; \
  161.         flags = (ti)->ti_flags & TH_FIN; \
  162.         tcpstat.tcps_rcvpack++;\
  163.         tcpstat.tcps_rcvbyte += (ti)->ti_len;\
  164.         sbappend(&(so)->so_rcv, (m)); \
  165.         sorwakeup(so); \
  166.     } else { \
  167.         (flags) = tcp_reass((tp), (ti), (m)); \
  168.         tp->t_flags |= TF_ACKNOW; \
  169.     } \
  170. }
  171.  
  172. int
  173. tcp_reass(tp, ti, m)
  174.     register struct tcpcb *tp;
  175.     register struct tcpiphdr *ti;
  176.     struct mbuf *m;
  177. {
  178.     register struct tcpiphdr *q;
  179.     struct socket *so = tp->t_inpcb->inp_socket;
  180.     int flags;
  181.  
  182.     /*
  183.      * Call with ti==0 after become established to
  184.      * force pre-ESTABLISHED data up to user socket.
  185.      */
  186.     if (ti == 0)
  187.         goto present;
  188.  
  189.     /*
  190.      * Find a segment which begins after this one does.
  191.      */
  192.     for (q = tp->seg_next; q != (struct tcpiphdr *)tp;
  193.         q = (struct tcpiphdr *)q->ti_next)
  194.         if (SEQ_GT(q->ti_seq, ti->ti_seq))
  195.             break;
  196.  
  197.     /*
  198.      * If there is a preceding segment, it may provide some of
  199.      * our data already.  If so, drop the data from the incoming
  200.      * segment.  If it provides all of our data, drop us.
  201.      */
  202.     if ((struct tcpiphdr *)q->ti_prev != (struct tcpiphdr *)tp) {
  203.         register int i;
  204.         q = (struct tcpiphdr *)q->ti_prev;
  205.         /* conversion to int (in i) handles seq wraparound */
  206.         i = q->ti_seq + q->ti_len - ti->ti_seq;
  207.         if (i > 0) {
  208.             if (i >= ti->ti_len) {
  209.                 tcpstat.tcps_rcvduppack++;
  210.                 tcpstat.tcps_rcvdupbyte += ti->ti_len;
  211.                 m_freem(m);
  212.                 return (0);
  213.             }
  214.             m_adj(m, i);
  215.             ti->ti_len -= i;
  216.             ti->ti_seq += i;
  217.         }
  218.         q = (struct tcpiphdr *)(q->ti_next);
  219.     }
  220.     tcpstat.tcps_rcvoopack++;
  221.     tcpstat.tcps_rcvoobyte += ti->ti_len;
  222.     REASS_MBUF(ti) = m;        /* XXX */
  223.  
  224.     /*
  225.      * While we overlap succeeding segments trim them or,
  226.      * if they are completely covered, dequeue them.
  227.      */
  228.     while (q != (struct tcpiphdr *)tp) {
  229.         register int i = (ti->ti_seq + ti->ti_len) - q->ti_seq;
  230.         if (i <= 0)
  231.             break;
  232.         if (i < q->ti_len) {
  233.             q->ti_seq += i;
  234.             q->ti_len -= i;
  235.             m_adj(REASS_MBUF(q), i);
  236.             break;
  237.         }
  238.         q = (struct tcpiphdr *)q->ti_next;
  239.         m = REASS_MBUF((struct tcpiphdr *)q->ti_prev);
  240.         remque(q->ti_prev);
  241.         m_freem(m);
  242.     }
  243.  
  244.     /*
  245.      * Stick new segment in its place.
  246.      */
  247.     insque(ti, q->ti_prev);
  248.  
  249. present:
  250.     /*
  251.      * Present data to user, advancing rcv_nxt through
  252.      * completed sequence space.
  253.      */
  254.     if (TCPS_HAVERCVDSYN(tp->t_state) == 0)
  255.         return (0);
  256.     ti = tp->seg_next;
  257.     if (ti == (struct tcpiphdr *)tp || ti->ti_seq != tp->rcv_nxt)
  258.         return (0);
  259.     if (tp->t_state == TCPS_SYN_RECEIVED && ti->ti_len)
  260.         return (0);
  261.     do {
  262.         tp->rcv_nxt += ti->ti_len;
  263.         flags = ti->ti_flags & TH_FIN;
  264.         remque(ti);
  265.         m = REASS_MBUF(ti);
  266.         ti = (struct tcpiphdr *)ti->ti_next;
  267.         if (so->so_state & SS_CANTRCVMORE)
  268.             m_freem(m);
  269.         else
  270.             sbappend(&so->so_rcv, m);
  271.     } while (ti != (struct tcpiphdr *)tp && ti->ti_seq == tp->rcv_nxt);
  272.     sorwakeup(so);
  273.     return (flags);
  274. }
  275.  
  276. /*
  277.  * TCP input routine, follows pages 65-76 of the
  278.  * protocol specification dated September, 1981 very closely.
  279.  */
  280. void STKARGFUN
  281. tcp_input(m, iphlen)
  282.     register struct mbuf *m;
  283.     int iphlen;
  284. {
  285.     register struct tcpiphdr *ti;
  286.     register struct inpcb *inp;
  287.     struct mbuf *om = 0;
  288.     int len, tlen, off;
  289.     register struct tcpcb *tp = 0;
  290.     register int tiflags;
  291.     struct socket *so;
  292.     int todrop, acked, ourfinisacked, needoutput = 0;
  293.     short ostate = 0;
  294.     struct in_addr laddr;
  295.     int dropsocket = 0;
  296.     int iss = 0;
  297.  
  298.     tcpstat.tcps_rcvtotal++;
  299.     /*
  300.      * Get IP and TCP header together in first mbuf.
  301.      * Note: IP leaves IP header in first mbuf.
  302.      */
  303.     ti = mtod(m, struct tcpiphdr *);
  304.     if (iphlen > sizeof (struct ip))
  305.         ip_stripoptions(m, (struct mbuf *)0);
  306.     if (m->m_len < sizeof (struct tcpiphdr)) {
  307.         if ((m = m_pullup(m, sizeof (struct tcpiphdr))) == 0) {
  308.             tcpstat.tcps_rcvshort++;
  309.             return;
  310.         }
  311.         ti = mtod(m, struct tcpiphdr *);
  312.     }
  313.  
  314.     /*
  315.      * Checksum extended TCP header and data.
  316.      */
  317.     tlen = ((struct ip *)ti)->ip_len;
  318.     len = sizeof (struct ip) + tlen;
  319.     ti->ti_next = ti->ti_prev = 0;
  320.     ti->ti_x1 = 0;
  321.     ti->ti_len = (u_short)tlen;
  322.     HTONS(ti->ti_len);
  323.     if (ti->ti_sum = in_cksum(m, len)) {
  324.         tcpstat.tcps_rcvbadsum++;
  325.         goto drop;
  326.     }
  327.  
  328.     /*
  329.      * Check that TCP offset makes sense,
  330.      * pull out TCP options and adjust length.        XXX
  331.      */
  332.     off = ti->ti_off << 2;
  333.     if (off < sizeof (struct tcphdr) || off > tlen) {
  334.         tcpstat.tcps_rcvbadoff++;
  335.         goto drop;
  336.     }
  337.     tlen -= off;
  338.     ti->ti_len = tlen;
  339.     if (off > sizeof (struct tcphdr)) {
  340.         if (m->m_len < sizeof(struct ip) + off) {
  341.             if ((m = m_pullup(m, sizeof (struct ip) + off)) == 0) {
  342.                 tcpstat.tcps_rcvshort++;
  343.                 return;
  344.             }
  345.             ti = mtod(m, struct tcpiphdr *);
  346.         }
  347.         om = m_get(M_DONTWAIT, MT_DATA);
  348.         if (om == 0)
  349.             goto drop;
  350.         om->m_len = off - sizeof (struct tcphdr);
  351.         { caddr_t op = mtod(m, caddr_t) + sizeof (struct tcpiphdr);
  352.           aligned_bcopy(op, mtod(om, caddr_t), (unsigned)om->m_len);
  353.           m->m_len -= om->m_len;
  354.           m->m_pkthdr.len -= om->m_len;
  355.           aligned_bcopy(op+om->m_len, op,
  356.            (unsigned)(m->m_len-sizeof (struct tcpiphdr)));
  357.         }
  358.     }
  359.     tiflags = ti->ti_flags;
  360.  
  361.     /*
  362.      * Convert TCP protocol specific fields to host format.
  363.      */
  364.     NTOHL(ti->ti_seq);
  365.     NTOHL(ti->ti_ack);
  366.     NTOHS(ti->ti_win);
  367.     NTOHS(ti->ti_urp);
  368.  
  369.     /*
  370.      * Locate pcb for segment.
  371.      */
  372. findpcb:
  373.     inp = tcp_last_inpcb;
  374.     if (inp->inp_lport != ti->ti_dport ||
  375.         inp->inp_fport != ti->ti_sport ||
  376.         inp->inp_faddr.s_addr != ti->ti_src.s_addr ||
  377.         inp->inp_laddr.s_addr != ti->ti_dst.s_addr) {
  378.         inp = in_pcblookup(&tcb, ti->ti_src, ti->ti_sport,
  379.             ti->ti_dst, ti->ti_dport, INPLOOKUP_WILDCARD);
  380.         if (inp)
  381.             tcp_last_inpcb = inp;
  382.         ++tcppcbcachemiss;
  383.     }
  384.  
  385.     /*
  386.      * If the state is CLOSED (i.e., TCB does not exist) then
  387.      * all data in the incoming segment is discarded.
  388.      * If the TCB exists but is in CLOSED state, it is embryonic,
  389.      * but should either do a listen or a connect soon.
  390.      */
  391.     if (inp == 0)
  392.         goto dropwithreset;
  393.     tp = intotcpcb(inp);
  394.     if (tp == 0)
  395.         goto dropwithreset;
  396.     if (tp->t_state == TCPS_CLOSED)
  397.         goto drop;
  398.     so = inp->inp_socket;
  399.     if (so->so_options & (SO_DEBUG|SO_ACCEPTCONN)) {
  400.         if (so->so_options & SO_DEBUG) {
  401.             ostate = tp->t_state;
  402.             tcp_saveti = *ti;
  403.         }
  404.         if (so->so_options & SO_ACCEPTCONN) {
  405. #ifdef AMITCP
  406.           /*
  407.            * call to access control.. (AmiTCP/IP extra)
  408.            */
  409.           if (controlaccess(ti->ti_src, ti->ti_dport) == 0)
  410.             goto dropwithreset;
  411. #endif          
  412.             so = sonewconn(so, 0);
  413.             if (so == 0)
  414.                 goto drop;
  415.             /*
  416.              * This is ugly, but ....
  417.              *
  418.              * Mark socket as temporary until we're
  419.              * committed to keeping it.  The code at
  420.              * ``drop'' and ``dropwithreset'' check the
  421.              * flag dropsocket to see if the temporary
  422.              * socket created here should be discarded.
  423.              * We mark the socket as discardable until
  424.              * we're committed to it below in TCPS_LISTEN.
  425.              */
  426.             dropsocket++;
  427.             inp = (struct inpcb *)so->so_pcb;
  428.             inp->inp_laddr = ti->ti_dst;
  429.             inp->inp_lport = ti->ti_dport;
  430. #if BSD>=43
  431.             inp->inp_options = ip_srcroute();
  432. #endif
  433.             tp = intotcpcb(inp);
  434.             tp->t_state = TCPS_LISTEN;
  435.         }
  436.     }
  437.  
  438.     /*
  439.      * Segment received on connection.
  440.      * Reset idle time and keep-alive timer.
  441.      */
  442.     tp->t_idle = 0;
  443.     tp->t_timer[TCPT_KEEP] = tcp_keepidle;
  444.  
  445.     /*
  446.      * Process options if not in LISTEN state,
  447.      * else do it below (after getting remote address).
  448.      */
  449.     if (om && tp->t_state != TCPS_LISTEN) {
  450.         tcp_dooptions(tp, om, ti);
  451.         om = 0;
  452.     }
  453.     /* 
  454.      * Header prediction: check for the two common cases
  455.      * of a uni-directional data xfer.  If the packet has
  456.      * no control flags, is in-sequence, the window didn't
  457.      * change and we're not retransmitting, it's a
  458.      * candidate.  If the length is zero and the ack moved
  459.      * forward, we're the sender side of the xfer.  Just
  460.      * free the data acked & wake any higher level process
  461.      * that was blocked waiting for space.  If the length
  462.      * is non-zero and the ack didn't move, we're the
  463.      * receiver side.  If we're getting packets in-order
  464.      * (the reassembly queue is empty), add the data to
  465.      * the socket buffer and note that we need a delayed ack.
  466.      */
  467.     if (tp->t_state == TCPS_ESTABLISHED &&
  468.         (tiflags & (TH_SYN|TH_FIN|TH_RST|TH_URG|TH_ACK)) == TH_ACK &&
  469.         ti->ti_seq == tp->rcv_nxt &&
  470.         ti->ti_win && ti->ti_win == tp->snd_wnd &&
  471.         tp->snd_nxt == tp->snd_max) {
  472.         if (ti->ti_len == 0) {
  473.             if (SEQ_GT(ti->ti_ack, tp->snd_una) &&
  474.                 SEQ_LEQ(ti->ti_ack, tp->snd_max) &&
  475.                 tp->snd_cwnd >= tp->snd_wnd) {
  476.                 /*
  477.                  * this is a pure ack for outstanding data.
  478.                  */
  479.                 ++tcppredack;
  480.                 if (tp->t_rtt && SEQ_GT(ti->ti_ack,tp->t_rtseq))
  481.                     tcp_xmit_timer(tp);
  482.                 acked = ti->ti_ack - tp->snd_una;
  483.                 tcpstat.tcps_rcvackpack++;
  484.                 tcpstat.tcps_rcvackbyte += acked;
  485.                 sbdrop(&so->so_snd, acked);
  486.                 tp->snd_una = ti->ti_ack;
  487.                 m_freem(m);
  488.  
  489.                 /*
  490.                  * If all outstanding data are acked, stop
  491.                  * retransmit timer, otherwise restart timer
  492.                  * using current (possibly backed-off) value.
  493.                  * If process is waiting for space,
  494.                  * wakeup/selwakeup/signal.  If data
  495.                  * are ready to send, let tcp_output
  496.                  * decide between more output or persist.
  497.                  */
  498.                 if (tp->snd_una == tp->snd_max)
  499.                     tp->t_timer[TCPT_REXMT] = 0;
  500.                 else if (tp->t_timer[TCPT_PERSIST] == 0)
  501.                     tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
  502.  
  503.                 if (so->so_snd.sb_flags & SB_NOTIFY)
  504.                     sowwakeup(so);
  505.                 if (so->so_snd.sb_cc)
  506.                     (void) tcp_output(tp);
  507.                 return;
  508.             }
  509.         } else if (ti->ti_ack == tp->snd_una &&
  510.             tp->seg_next == (struct tcpiphdr *)tp &&
  511.             ti->ti_len <= sbspace(&so->so_rcv)) {
  512.             /*
  513.              * this is a pure, in-sequence data packet
  514.              * with nothing on the reassembly queue and
  515.              * we have enough buffer space to take it.
  516.              */
  517.             ++tcppreddat;
  518.             tp->rcv_nxt += ti->ti_len;
  519.             tcpstat.tcps_rcvpack++;
  520.             tcpstat.tcps_rcvbyte += ti->ti_len;
  521.             /*
  522.              * Drop TCP and IP headers then add data
  523.              * to socket buffer
  524.              */
  525.             m->m_data += sizeof(struct tcpiphdr);
  526.             m->m_len -= sizeof(struct tcpiphdr);
  527.             sbappend(&so->so_rcv, m);
  528.             sorwakeup(so);
  529.             tp->t_flags |= TF_DELACK;
  530.             return;
  531.         }
  532.     }
  533.  
  534.     /*
  535.      * Drop TCP and IP headers; TCP options were dropped above.
  536.      */
  537.     m->m_data += sizeof(struct tcpiphdr);
  538.     m->m_len -= sizeof(struct tcpiphdr);
  539.  
  540.     /*
  541.      * Calculate amount of space in receive window,
  542.      * and then do TCP input processing.
  543.      * Receive window is amount of space in rcv queue,
  544.      * but not less than advertised window.
  545.      */
  546.     { int win;
  547.  
  548.     win = sbspace(&so->so_rcv);
  549.     if (win < 0)
  550.         win = 0;
  551.     tp->rcv_wnd = max(win, (int)(tp->rcv_adv - tp->rcv_nxt));
  552.     }
  553.  
  554.     switch (tp->t_state) {
  555.  
  556.     /*
  557.      * If the state is LISTEN then ignore segment if it contains an RST.
  558.      * If the segment contains an ACK then it is bad and send a RST.
  559.      * If it does not contain a SYN then it is not interesting; drop it.
  560.      * Don't bother responding if the destination was a broadcast.
  561.      * Otherwise initialize tp->rcv_nxt, and tp->irs, select an initial
  562.      * tp->iss, and send a segment:
  563.      *     <SEQ=ISS><ACK=RCV_NXT><CTL=SYN,ACK>
  564.      * Also initialize tp->snd_nxt to tp->iss+1 and tp->snd_una to tp->iss.
  565.      * Fill in remote peer address fields if not previously specified.
  566.      * Enter SYN_RECEIVED state, and process any other fields of this
  567.      * segment in this state.
  568.      */
  569.     case TCPS_LISTEN: {
  570.         struct mbuf *am;
  571.         register struct sockaddr_in *sin;
  572.  
  573.         if (tiflags & TH_RST)
  574.             goto drop;
  575.         if (tiflags & TH_ACK)
  576.             goto dropwithreset;
  577.         if ((tiflags & TH_SYN) == 0)
  578.             goto drop;
  579.         if (m->m_flags & M_BCAST)
  580.             goto drop;
  581.         am = m_get(M_DONTWAIT, MT_SONAME);    /* XXX */
  582.         if (am == NULL)
  583.             goto drop;
  584.         am->m_len = sizeof (struct sockaddr_in);
  585.         sin = mtod(am, struct sockaddr_in *);
  586.         sin->sin_family = AF_INET;
  587.         sin->sin_len = sizeof(*sin);
  588.         sin->sin_addr = ti->ti_src;
  589.         sin->sin_port = ti->ti_sport;
  590.         laddr = inp->inp_laddr;
  591.         if (inp->inp_laddr.s_addr == INADDR_ANY)
  592.             inp->inp_laddr = ti->ti_dst;
  593.         if (in_pcbconnect(inp, am)) {
  594.             inp->inp_laddr = laddr;
  595.             (void) m_free(am);
  596.             goto drop;
  597.         }
  598.         (void) m_free(am);
  599.         tp->t_template = tcp_template(tp);
  600.         if (tp->t_template == 0) {
  601.             tp = tcp_drop(tp, ENOBUFS);
  602.             dropsocket = 0;        /* socket is already gone */
  603.             goto drop;
  604.         }
  605.         if (om) {
  606.             tcp_dooptions(tp, om, ti);
  607.             om = 0;
  608.         }
  609.         if (iss)
  610.             tp->iss = iss;
  611.         else
  612.             tp->iss = tcp_iss;
  613.         tcp_iss += TCP_ISSINCR/2;
  614.         tp->irs = ti->ti_seq;
  615.         tcp_sendseqinit(tp);
  616.         tcp_rcvseqinit(tp);
  617.         tp->t_flags |= TF_ACKNOW;
  618.         tp->t_state = TCPS_SYN_RECEIVED;
  619.         tp->t_timer[TCPT_KEEP] = TCPTV_KEEP_INIT;
  620.         dropsocket = 0;        /* committed to socket */
  621.         tcpstat.tcps_accepts++;
  622.         goto trimthenstep6;
  623.         }
  624.  
  625.     /*
  626.      * If the state is SYN_SENT:
  627.      *    if seg contains an ACK, but not for our SYN, drop the input.
  628.      *    if seg contains a RST, then drop the connection.
  629.      *    if seg does not contain SYN, then drop it.
  630.      * Otherwise this is an acceptable SYN segment
  631.      *    initialize tp->rcv_nxt and tp->irs
  632.      *    if seg contains ack then advance tp->snd_una
  633.      *    if SYN has been acked change to ESTABLISHED else SYN_RCVD state
  634.      *    arrange for segment to be acked (eventually)
  635.      *    continue processing rest of data/controls, beginning with URG
  636.      */
  637.     case TCPS_SYN_SENT:
  638.         if ((tiflags & TH_ACK) &&
  639.             (SEQ_LEQ(ti->ti_ack, tp->iss) ||
  640.              SEQ_GT(ti->ti_ack, tp->snd_max)))
  641.             goto dropwithreset;
  642.         if (tiflags & TH_RST) {
  643.             if (tiflags & TH_ACK)
  644.                 tp = tcp_drop(tp, ECONNREFUSED);
  645.             goto drop;
  646.         }
  647.         if ((tiflags & TH_SYN) == 0)
  648.             goto drop;
  649.         if (tiflags & TH_ACK) {
  650.             tp->snd_una = ti->ti_ack;
  651.             if (SEQ_LT(tp->snd_nxt, tp->snd_una))
  652.                 tp->snd_nxt = tp->snd_una;
  653.         }
  654.         tp->t_timer[TCPT_REXMT] = 0;
  655.         tp->irs = ti->ti_seq;
  656.         tcp_rcvseqinit(tp);
  657.         tp->t_flags |= TF_ACKNOW;
  658.         if (tiflags & TH_ACK && SEQ_GT(tp->snd_una, tp->iss)) {
  659.             tcpstat.tcps_connects++;
  660.             soisconnected(so);
  661.             tp->t_state = TCPS_ESTABLISHED;
  662.             (void) tcp_reass(tp, (struct tcpiphdr *)0,
  663.                 (struct mbuf *)0);
  664.             /*
  665.              * if we didn't have to retransmit the SYN,
  666.              * use its rtt as our initial srtt & rtt var.
  667.              */
  668.             if (tp->t_rtt)
  669.                 tcp_xmit_timer(tp);
  670.         } else
  671.             tp->t_state = TCPS_SYN_RECEIVED;
  672.  
  673. trimthenstep6:
  674.         /*
  675.          * Advance ti->ti_seq to correspond to first data byte.
  676.          * If data, trim to stay within window,
  677.          * dropping FIN if necessary.
  678.          */
  679.         ti->ti_seq++;
  680.         if ((u_short)ti->ti_len > tp->rcv_wnd) {
  681.             todrop = ti->ti_len - tp->rcv_wnd;
  682.             m_adj(m, -todrop);
  683.             ti->ti_len = tp->rcv_wnd;
  684.             tiflags &= ~TH_FIN;
  685.             tcpstat.tcps_rcvpackafterwin++;
  686.             tcpstat.tcps_rcvbyteafterwin += todrop;
  687.         }
  688.         tp->snd_wl1 = ti->ti_seq - 1;
  689.         tp->rcv_up = ti->ti_seq;
  690.         goto step6;
  691.     }
  692.  
  693.     /*
  694.      * States other than LISTEN or SYN_SENT.
  695.      * First check that at least some bytes of segment are within 
  696.      * receive window.  If segment begins before rcv_nxt,
  697.      * drop leading data (and SYN); if nothing left, just ack.
  698.      */
  699.     todrop = tp->rcv_nxt - ti->ti_seq;
  700.     if (todrop > 0) {
  701.         if (tiflags & TH_SYN) {
  702.             tiflags &= ~TH_SYN;
  703.             ti->ti_seq++;
  704.             if (ti->ti_urp > 1) 
  705.                 ti->ti_urp--;
  706.             else
  707.                 tiflags &= ~TH_URG;
  708.             todrop--;
  709.         }
  710.         if (todrop > ti->ti_len ||
  711.             (todrop == ti->ti_len && (tiflags&TH_FIN) == 0)) {
  712.             tcpstat.tcps_rcvduppack++;
  713.             tcpstat.tcps_rcvdupbyte += ti->ti_len;
  714.             /*
  715.              * If segment is just one to the left of the window,
  716.              * check two special cases:
  717.              * 1. Don't toss RST in response to 4.2-style keepalive.
  718.              * 2. If the only thing to drop is a FIN, we can drop
  719.              *    it, but check the ACK or we will get into FIN
  720.              *    wars if our FINs crossed (both CLOSING).
  721.              * In either case, send ACK to resynchronize,
  722.              * but keep on processing for RST or ACK.
  723.              */
  724.             if ((tiflags & TH_FIN && todrop == ti->ti_len + 1)
  725. #if TCP_COMPAT_42
  726.               || (tiflags & TH_RST && ti->ti_seq == tp->rcv_nxt - 1)
  727. #endif
  728.                ) {
  729.                 todrop = ti->ti_len;
  730.                 tiflags &= ~TH_FIN;
  731.                 tp->t_flags |= TF_ACKNOW;
  732.             } else
  733.                 goto dropafterack;
  734.         } else {
  735.             tcpstat.tcps_rcvpartduppack++;
  736.             tcpstat.tcps_rcvpartdupbyte += todrop;
  737.         }
  738.         m_adj(m, todrop);
  739.         ti->ti_seq += todrop;
  740.         ti->ti_len -= todrop;
  741.         if (ti->ti_urp > todrop)
  742.             ti->ti_urp -= todrop;
  743.         else {
  744.             tiflags &= ~TH_URG;
  745.             ti->ti_urp = 0;
  746.         }
  747.     }
  748.  
  749.     /*
  750.      * If new data are received on a connection after the
  751.      * user processes are gone, then RST the other end.
  752.      */
  753.     if ((so->so_state & SS_NOFDREF) &&
  754.         tp->t_state > TCPS_CLOSE_WAIT && ti->ti_len) {
  755.         tp = tcp_close(tp);
  756.         tcpstat.tcps_rcvafterclose++;
  757.         goto dropwithreset;
  758.     }
  759.  
  760.     /*
  761.      * If segment ends after window, drop trailing data
  762.      * (and PUSH and FIN); if nothing left, just ACK.
  763.      */
  764.     todrop = (ti->ti_seq+ti->ti_len) - (tp->rcv_nxt+tp->rcv_wnd);
  765.     if (todrop > 0) {
  766.         tcpstat.tcps_rcvpackafterwin++;
  767.         if (todrop >= ti->ti_len) {
  768.             tcpstat.tcps_rcvbyteafterwin += ti->ti_len;
  769.             /*
  770.              * If a new connection request is received
  771.              * while in TIME_WAIT, drop the old connection
  772.              * and start over if the sequence numbers
  773.              * are above the previous ones.
  774.              */
  775.             if (tiflags & TH_SYN &&
  776.                 tp->t_state == TCPS_TIME_WAIT &&
  777.                 SEQ_GT(ti->ti_seq, tp->rcv_nxt)) {
  778.                 iss = tp->rcv_nxt + TCP_ISSINCR;
  779.                 tp = tcp_close(tp);
  780.                 goto findpcb;
  781.             }
  782.             /*
  783.              * If window is closed can only take segments at
  784.              * window edge, and have to drop data and PUSH from
  785.              * incoming segments.  Continue processing, but
  786.              * remember to ack.  Otherwise, drop segment
  787.              * and ack.
  788.              */
  789.             if (tp->rcv_wnd == 0 && ti->ti_seq == tp->rcv_nxt) {
  790.                 tp->t_flags |= TF_ACKNOW;
  791.                 tcpstat.tcps_rcvwinprobe++;
  792.             } else
  793.                 goto dropafterack;
  794.         } else
  795.             tcpstat.tcps_rcvbyteafterwin += todrop;
  796.         m_adj(m, -todrop);
  797.         ti->ti_len -= todrop;
  798.         tiflags &= ~(TH_PUSH|TH_FIN);
  799.     }
  800.  
  801.     /*
  802.      * If the RST bit is set examine the state:
  803.      *    SYN_RECEIVED STATE:
  804.      *    If passive open, return to LISTEN state.
  805.      *    If active open, inform user that connection was refused.
  806.      *    ESTABLISHED, FIN_WAIT_1, FIN_WAIT2, CLOSE_WAIT STATES:
  807.      *    Inform user that connection was reset, and close tcb.
  808.      *    CLOSING, LAST_ACK, TIME_WAIT STATES
  809.      *    Close the tcb.
  810.      */
  811.     if (tiflags&TH_RST) switch (tp->t_state) {
  812.  
  813.     case TCPS_SYN_RECEIVED:
  814.         so->so_error = ECONNREFUSED;
  815.         goto close;
  816.  
  817.     case TCPS_ESTABLISHED:
  818.     case TCPS_FIN_WAIT_1:
  819.     case TCPS_FIN_WAIT_2:
  820.     case TCPS_CLOSE_WAIT:
  821.         so->so_error = ECONNRESET;
  822.     close:
  823.         tp->t_state = TCPS_CLOSED;
  824.         tcpstat.tcps_drops++;
  825.         tp = tcp_close(tp);
  826.         goto drop;
  827.  
  828.     case TCPS_CLOSING:
  829.     case TCPS_LAST_ACK:
  830.     case TCPS_TIME_WAIT:
  831.         tp = tcp_close(tp);
  832.         goto drop;
  833.     }
  834.  
  835.     /*
  836.      * If a SYN is in the window, then this is an
  837.      * error and we send an RST and drop the connection.
  838.      */
  839.     if (tiflags & TH_SYN) {
  840.         tp = tcp_drop(tp, ECONNRESET);
  841.         goto dropwithreset;
  842.     }
  843.  
  844.     /*
  845.      * If the ACK bit is off we drop the segment and return.
  846.      */
  847.     if ((tiflags & TH_ACK) == 0)
  848.         goto drop;
  849.     
  850.     /*
  851.      * Ack processing.
  852.      */
  853.     switch (tp->t_state) {
  854.  
  855.     /*
  856.      * In SYN_RECEIVED state if the ack ACKs our SYN then enter
  857.      * ESTABLISHED state and continue processing, otherwise
  858.      * send an RST.
  859.      */
  860.     case TCPS_SYN_RECEIVED:
  861.         if (SEQ_GT(tp->snd_una, ti->ti_ack) ||
  862.             SEQ_GT(ti->ti_ack, tp->snd_max))
  863.             goto dropwithreset;
  864.         tcpstat.tcps_connects++;
  865.         soisconnected(so);
  866.         tp->t_state = TCPS_ESTABLISHED;
  867.         (void) tcp_reass(tp, (struct tcpiphdr *)0, (struct mbuf *)0);
  868.         tp->snd_wl1 = ti->ti_seq - 1;
  869.         /* fall into ... */
  870.  
  871.     /*
  872.      * In ESTABLISHED state: drop duplicate ACKs; ACK out of range
  873.      * ACKs.  If the ack is in the range
  874.      *    tp->snd_una < ti->ti_ack <= tp->snd_max
  875.      * then advance tp->snd_una to ti->ti_ack and drop
  876.      * data from the retransmission queue.  If this ACK reflects
  877.      * more up to date window information we update our window information.
  878.      */
  879.     case TCPS_ESTABLISHED:
  880.     case TCPS_FIN_WAIT_1:
  881.     case TCPS_FIN_WAIT_2:
  882.     case TCPS_CLOSE_WAIT:
  883.     case TCPS_CLOSING:
  884.     case TCPS_LAST_ACK:
  885.     case TCPS_TIME_WAIT:
  886.  
  887.         if (SEQ_LEQ(ti->ti_ack, tp->snd_una)) {
  888.             if (ti->ti_len == 0 && ti->ti_win == tp->snd_wnd) {
  889.                 tcpstat.tcps_rcvdupack++;
  890.                 /*
  891.                  * If we have outstanding data (other than
  892.                  * a window probe), this is a completely
  893.                  * duplicate ack (ie, window info didn't
  894.                  * change), the ack is the biggest we've
  895.                  * seen and we've seen exactly our rexmt
  896.                  * threshhold of them, assume a packet
  897.                  * has been dropped and retransmit it.
  898.                  * Kludge snd_nxt & the congestion
  899.                  * window so we send only this one
  900.                  * packet.
  901.                  *
  902.                  * We know we're losing at the current
  903.                  * window size so do congestion avoidance
  904.                  * (set ssthresh to half the current window
  905.                  * and pull our congestion window back to
  906.                  * the new ssthresh).
  907.                  *
  908.                  * Dup acks mean that packets have left the
  909.                  * network (they're now cached at the receiver) 
  910.                  * so bump cwnd by the amount in the receiver
  911.                  * to keep a constant cwnd packets in the
  912.                  * network.
  913.                  */
  914.                 if (tp->t_timer[TCPT_REXMT] == 0 ||
  915.                     ti->ti_ack != tp->snd_una)
  916.                     tp->t_dupacks = 0;
  917.                 else if (++tp->t_dupacks == tcprexmtthresh) {
  918.                     tcp_seq onxt = tp->snd_nxt;
  919.                     u_int win =
  920.                         min(tp->snd_wnd, tp->snd_cwnd) / 2 /
  921.                         tp->t_maxseg;
  922.  
  923.                     if (win < 2)
  924.                         win = 2;
  925.                     tp->snd_ssthresh = win * tp->t_maxseg;
  926.                     tp->t_timer[TCPT_REXMT] = 0;
  927.                     tp->t_rtt = 0;
  928.                     tp->snd_nxt = ti->ti_ack;
  929.                     tp->snd_cwnd = tp->t_maxseg;
  930.                     (void) tcp_output(tp);
  931.                     tp->snd_cwnd = tp->snd_ssthresh +
  932.                            tp->t_maxseg * tp->t_dupacks;
  933.                     if (SEQ_GT(onxt, tp->snd_nxt))
  934.                         tp->snd_nxt = onxt;
  935.                     goto drop;
  936.                 } else if (tp->t_dupacks > tcprexmtthresh) {
  937.                     tp->snd_cwnd += tp->t_maxseg;
  938.                     (void) tcp_output(tp);
  939.                     goto drop;
  940.                 }
  941.             } else
  942.                 tp->t_dupacks = 0;
  943.             break;
  944.         }
  945.         /*
  946.          * If the congestion window was inflated to account
  947.          * for the other side's cached packets, retract it.
  948.          */
  949.         if (tp->t_dupacks > tcprexmtthresh &&
  950.             tp->snd_cwnd > tp->snd_ssthresh)
  951.             tp->snd_cwnd = tp->snd_ssthresh;
  952.         tp->t_dupacks = 0;
  953.         if (SEQ_GT(ti->ti_ack, tp->snd_max)) {
  954.             tcpstat.tcps_rcvacktoomuch++;
  955.             goto dropafterack;
  956.         }
  957.         acked = ti->ti_ack - tp->snd_una;
  958.         tcpstat.tcps_rcvackpack++;
  959.         tcpstat.tcps_rcvackbyte += acked;
  960.  
  961.         /*
  962.          * If transmit timer is running and timed sequence
  963.          * number was acked, update smoothed round trip time.
  964.          * Since we now have an rtt measurement, cancel the
  965.          * timer backoff (cf., Phil Karn's retransmit alg.).
  966.          * Recompute the initial retransmit timer.
  967.          */
  968.         if (tp->t_rtt && SEQ_GT(ti->ti_ack, tp->t_rtseq))
  969.             tcp_xmit_timer(tp);
  970.  
  971.         /*
  972.          * If all outstanding data is acked, stop retransmit
  973.          * timer and remember to restart (more output or persist).
  974.          * If there is more data to be acked, restart retransmit
  975.          * timer, using current (possibly backed-off) value.
  976.          */
  977.         if (ti->ti_ack == tp->snd_max) {
  978.             tp->t_timer[TCPT_REXMT] = 0;
  979.             needoutput = 1;
  980.         } else if (tp->t_timer[TCPT_PERSIST] == 0)
  981.             tp->t_timer[TCPT_REXMT] = tp->t_rxtcur;
  982.         /*
  983.          * When new data is acked, open the congestion window.
  984.          * If the window gives us less than ssthresh packets
  985.          * in flight, open exponentially (maxseg per packet).
  986.          * Otherwise open linearly: maxseg per window
  987.          * (maxseg^2 / cwnd per packet), plus a constant
  988.          * fraction of a packet (maxseg/8) to help larger windows
  989.          * open quickly enough.
  990.          */
  991.         {
  992.         register u_int cw = tp->snd_cwnd;
  993.         register u_int incr = tp->t_maxseg;
  994.  
  995.         if (cw > tp->snd_ssthresh)
  996.             incr = incr * incr / cw + incr / 8;
  997.         tp->snd_cwnd = min(cw + incr, TCP_MAXWIN);
  998.         }
  999.         if (acked > so->so_snd.sb_cc) {
  1000.             tp->snd_wnd -= so->so_snd.sb_cc;
  1001.             sbdrop(&so->so_snd, (int)so->so_snd.sb_cc);
  1002.             ourfinisacked = 1;
  1003.         } else {
  1004.             sbdrop(&so->so_snd, acked);
  1005.             tp->snd_wnd -= acked;
  1006.             ourfinisacked = 0;
  1007.         }
  1008.         if (so->so_snd.sb_flags & SB_NOTIFY)
  1009.             sowwakeup(so);
  1010.         tp->snd_una = ti->ti_ack;
  1011.         if (SEQ_LT(tp->snd_nxt, tp->snd_una))
  1012.             tp->snd_nxt = tp->snd_una;
  1013.  
  1014.         switch (tp->t_state) {
  1015.  
  1016.         /*
  1017.          * In FIN_WAIT_1 STATE in addition to the processing
  1018.          * for the ESTABLISHED state if our FIN is now acknowledged
  1019.          * then enter FIN_WAIT_2.
  1020.          */
  1021.         case TCPS_FIN_WAIT_1:
  1022.             if (ourfinisacked) {
  1023.                 /*
  1024.                  * If we can't receive any more
  1025.                  * data, then closing user can proceed.
  1026.                  * Starting the timer is contrary to the
  1027.                  * specification, but if we don't get a FIN
  1028.                  * we'll hang forever.
  1029.                  */
  1030.                 if (so->so_state & SS_CANTRCVMORE) {
  1031.                     soisdisconnected(so);
  1032.                     tp->t_timer[TCPT_2MSL] = tcp_maxidle;
  1033.                 }
  1034.                 tp->t_state = TCPS_FIN_WAIT_2;
  1035.             }
  1036.             break;
  1037.  
  1038.          /*
  1039.          * In CLOSING STATE in addition to the processing for
  1040.          * the ESTABLISHED state if the ACK acknowledges our FIN
  1041.          * then enter the TIME-WAIT state, otherwise ignore
  1042.          * the segment.
  1043.          */
  1044.         case TCPS_CLOSING:
  1045.             if (ourfinisacked) {
  1046.                 tp->t_state = TCPS_TIME_WAIT;
  1047.                 tcp_canceltimers(tp);
  1048.                 tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
  1049.                 soisdisconnected(so);
  1050.             }
  1051.             break;
  1052.  
  1053.         /*
  1054.          * In LAST_ACK, we may still be waiting for data to drain
  1055.          * and/or to be acked, as well as for the ack of our FIN.
  1056.          * If our FIN is now acknowledged, delete the TCB,
  1057.          * enter the closed state and return.
  1058.          */
  1059.         case TCPS_LAST_ACK:
  1060.             if (ourfinisacked) {
  1061.                 tp = tcp_close(tp);
  1062.                 goto drop;
  1063.             }
  1064.             break;
  1065.  
  1066.         /*
  1067.          * In TIME_WAIT state the only thing that should arrive
  1068.          * is a retransmission of the remote FIN.  Acknowledge
  1069.          * it and restart the finack timer.
  1070.          */
  1071.         case TCPS_TIME_WAIT:
  1072.             tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
  1073.             goto dropafterack;
  1074.         }
  1075.     }
  1076.  
  1077. step6:
  1078.     /*
  1079.      * Update window information.
  1080.      * Don't look at window if no ACK: TAC's send garbage on first SYN.
  1081.      */
  1082.     if ((tiflags & TH_ACK) &&
  1083.         (SEQ_LT(tp->snd_wl1, ti->ti_seq) || 
  1084.          (tp->snd_wl1 == ti->ti_seq &&
  1085.           (SEQ_LT(tp->snd_wl2, ti->ti_ack) ||
  1086.            (tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd))))) {
  1087.             /* keep track of pure window updates */
  1088.         if (ti->ti_len == 0 &&
  1089.             tp->snd_wl2 == ti->ti_ack && ti->ti_win > tp->snd_wnd)
  1090.             tcpstat.tcps_rcvwinupd++;
  1091.         tp->snd_wnd = ti->ti_win;
  1092.         tp->snd_wl1 = ti->ti_seq;
  1093.         tp->snd_wl2 = ti->ti_ack;
  1094.         if (tp->snd_wnd > tp->max_sndwnd)
  1095.             tp->max_sndwnd = tp->snd_wnd;
  1096.         needoutput = 1;
  1097.     }
  1098.  
  1099.     /*
  1100.      * Process segments with URG.
  1101.      */
  1102.     if ((tiflags & TH_URG) && ti->ti_urp &&
  1103.         TCPS_HAVERCVDFIN(tp->t_state) == 0) {
  1104.         /*
  1105.          * This is a kludge, but if we receive and accept
  1106.          * random urgent pointers, we'll crash in
  1107.          * soreceive.  It's hard to imagine someone
  1108.          * actually wanting to send this much urgent data.
  1109.          */
  1110.         if (ti->ti_urp + so->so_rcv.sb_cc > SB_MAX) {
  1111.             ti->ti_urp = 0;            /* XXX */
  1112.             tiflags &= ~TH_URG;        /* XXX */
  1113.             goto dodata;            /* XXX */
  1114.         }
  1115.         /*
  1116.          * If this segment advances the known urgent pointer,
  1117.          * then mark the data stream.  This should not happen
  1118.          * in CLOSE_WAIT, CLOSING, LAST_ACK or TIME_WAIT STATES since
  1119.          * a FIN has been received from the remote side. 
  1120.          * In these states we ignore the URG.
  1121.          *
  1122.          * According to RFC961 (Assigned Protocols),
  1123.          * the urgent pointer points to the last octet
  1124.          * of urgent data.  We continue, however,
  1125.          * to consider it to indicate the first octet
  1126.          * of data past the urgent section as the original 
  1127.          * spec states (in one of two places).
  1128.          */
  1129.         if (SEQ_GT(ti->ti_seq+ti->ti_urp, tp->rcv_up)) {
  1130.             tp->rcv_up = ti->ti_seq + ti->ti_urp;
  1131.             so->so_oobmark = so->so_rcv.sb_cc +
  1132.                 (tp->rcv_up - tp->rcv_nxt) - 1;
  1133.             if (so->so_oobmark == 0)
  1134.                 so->so_state |= SS_RCVATMARK;
  1135.             sohasoutofband(so);
  1136.             tp->t_oobflags &= ~(TCPOOB_HAVEDATA | TCPOOB_HADDATA);
  1137.         }
  1138.         /*
  1139.          * Remove out of band data so doesn't get presented to user.
  1140.          * This can happen independent of advancing the URG pointer,
  1141.          * but if two URG's are pending at once, some out-of-band
  1142.          * data may creep in... ick.
  1143.          */
  1144.         if (ti->ti_urp <= (u_short)ti->ti_len
  1145. #ifdef SO_OOBINLINE
  1146.              && (so->so_options & SO_OOBINLINE) == 0
  1147. #endif
  1148.              )
  1149.             tcp_pulloutofband(so, ti, m);
  1150.     } else
  1151.         /*
  1152.          * If no out of band data is expected,
  1153.          * pull receive urgent pointer along
  1154.          * with the receive window.
  1155.          */
  1156.         if (SEQ_GT(tp->rcv_nxt, tp->rcv_up))
  1157.             tp->rcv_up = tp->rcv_nxt;
  1158. dodata:                            /* XXX */
  1159.  
  1160.     /*
  1161.      * Process the segment text, merging it into the TCP sequencing queue,
  1162.      * and arranging for acknowledgment of receipt if necessary.
  1163.      * This process logically involves adjusting tp->rcv_wnd as data
  1164.      * is presented to the user (this happens in tcp_usrreq.c,
  1165.      * case PRU_RCVD).  If a FIN has already been received on this
  1166.      * connection then we just ignore the text.
  1167.      */
  1168.     if ((ti->ti_len || (tiflags&TH_FIN)) &&
  1169.         TCPS_HAVERCVDFIN(tp->t_state) == 0) {
  1170.         TCP_REASS(tp, ti, m, so, tiflags);
  1171.         /*
  1172.          * Note the amount of data that peer has sent into
  1173.          * our window, in order to estimate the sender's
  1174.          * buffer size.
  1175.          */
  1176.         len = so->so_rcv.sb_hiwat - (tp->rcv_adv - tp->rcv_nxt);
  1177.     } else {
  1178.         m_freem(m);
  1179.         tiflags &= ~TH_FIN;
  1180.     }
  1181.  
  1182.     /*
  1183.      * If FIN is received ACK the FIN and let the user know
  1184.      * that the connection is closing.
  1185.      */
  1186.     if (tiflags & TH_FIN) {
  1187.         if (TCPS_HAVERCVDFIN(tp->t_state) == 0) {
  1188.             socantrcvmore(so);
  1189.             tp->t_flags |= TF_ACKNOW;
  1190.             tp->rcv_nxt++;
  1191.         }
  1192.         switch (tp->t_state) {
  1193.  
  1194.          /*
  1195.          * In SYN_RECEIVED and ESTABLISHED STATES
  1196.          * enter the CLOSE_WAIT state.
  1197.          */
  1198.         case TCPS_SYN_RECEIVED:
  1199.         case TCPS_ESTABLISHED:
  1200.             tp->t_state = TCPS_CLOSE_WAIT;
  1201.             break;
  1202.  
  1203.          /*
  1204.          * If still in FIN_WAIT_1 STATE FIN has not been acked so
  1205.          * enter the CLOSING state.
  1206.          */
  1207.         case TCPS_FIN_WAIT_1:
  1208.             tp->t_state = TCPS_CLOSING;
  1209.             break;
  1210.  
  1211.          /*
  1212.          * In FIN_WAIT_2 state enter the TIME_WAIT state,
  1213.          * starting the time-wait timer, turning off the other 
  1214.          * standard timers.
  1215.          */
  1216.         case TCPS_FIN_WAIT_2:
  1217.             tp->t_state = TCPS_TIME_WAIT;
  1218.             tcp_canceltimers(tp);
  1219.             tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
  1220.             soisdisconnected(so);
  1221.             break;
  1222.  
  1223.         /*
  1224.          * In TIME_WAIT state restart the 2 MSL time_wait timer.
  1225.          */
  1226.         case TCPS_TIME_WAIT:
  1227.             tp->t_timer[TCPT_2MSL] = 2 * TCPTV_MSL;
  1228.             break;
  1229.         }
  1230.     }
  1231.     if (so->so_options & SO_DEBUG)
  1232.         tcp_trace(TA_INPUT, ostate, tp, &tcp_saveti, 0);
  1233.  
  1234.     /*
  1235.      * Return any desired output.
  1236.      */
  1237.     if (needoutput || (tp->t_flags & TF_ACKNOW))
  1238.         (void) tcp_output(tp);
  1239.     return;
  1240.  
  1241. dropafterack:
  1242.     /*
  1243.      * Generate an ACK dropping incoming segment if it occupies
  1244.      * sequence space, where the ACK reflects our state.
  1245.      */
  1246.     if (tiflags & TH_RST)
  1247.         goto drop;
  1248.     m_freem(m);
  1249.     tp->t_flags |= TF_ACKNOW;
  1250.     (void) tcp_output(tp);
  1251.     return;
  1252.  
  1253. dropwithreset:
  1254.     if (om) {
  1255.         (void) m_free(om);
  1256.         om = 0;
  1257.     }
  1258.     /*
  1259.      * Generate a RST, dropping incoming segment.
  1260.      * Make ACK acceptable to originator of segment.
  1261.      * Don't bother to respond if destination was broadcast.
  1262.      */
  1263.     if ((tiflags & TH_RST) || m->m_flags & M_BCAST)
  1264.         goto drop;
  1265.     if (tiflags & TH_ACK)
  1266.         tcp_respond(tp, ti, m, (tcp_seq)0, ti->ti_ack, TH_RST);
  1267.     else {
  1268.         if (tiflags & TH_SYN)
  1269.             ti->ti_len++;
  1270.         tcp_respond(tp, ti, m, ti->ti_seq+ti->ti_len, (tcp_seq)0,
  1271.             TH_RST|TH_ACK);
  1272.     }
  1273.     /* destroy temporarily created socket */
  1274.     if (dropsocket)
  1275.         (void) soabort(so);
  1276.     return;
  1277.  
  1278. drop:
  1279.     if (om)
  1280.         (void) m_free(om);
  1281.     /*
  1282.      * Drop space held by incoming segment and return.
  1283.      */
  1284.     if (tp && (tp->t_inpcb->inp_socket->so_options & SO_DEBUG))
  1285.         tcp_trace(TA_DROP, ostate, tp, &tcp_saveti, 0);
  1286.     m_freem(m);
  1287.     /* destroy temporarily created socket */
  1288.     if (dropsocket)
  1289.         (void) soabort(so);
  1290.     return;
  1291. }
  1292.  
  1293. void
  1294. tcp_dooptions(tp, om, ti)
  1295.     struct tcpcb *tp;
  1296.     struct mbuf *om;
  1297.     struct tcpiphdr *ti;
  1298. {
  1299.     register u_char *cp;
  1300.     u_short mss;
  1301.     int opt, optlen, cnt;
  1302.  
  1303.     cp = mtod(om, u_char *);
  1304.     cnt = om->m_len;
  1305.     for (; cnt > 0; cnt -= optlen, cp += optlen) {
  1306.         opt = cp[0];
  1307.         if (opt == TCPOPT_EOL)
  1308.             break;
  1309.         if (opt == TCPOPT_NOP)
  1310.             optlen = 1;
  1311.         else {
  1312.             optlen = cp[1];
  1313.             if (optlen <= 0)
  1314.                 break;
  1315.         }
  1316.         switch (opt) {
  1317.  
  1318.         default:
  1319.             continue;
  1320.  
  1321.         case TCPOPT_MAXSEG:
  1322.             if (optlen != 4)
  1323.                 continue;
  1324.             if (!(ti->ti_flags & TH_SYN))
  1325.                 continue;
  1326.             bcopy((char *) cp + 2, (char *) &mss, sizeof(mss));
  1327.             NTOHS(mss);
  1328.             (void) tcp_mss(tp, mss);    /* sets t_maxseg */
  1329.             break;
  1330.         }
  1331.     }
  1332.     (void) m_free(om);
  1333. }
  1334.  
  1335. /*
  1336.  * Pull out of band byte out of a segment so
  1337.  * it doesn't appear in the user's data queue.
  1338.  * It is still reflected in the segment length for
  1339.  * sequencing purposes.
  1340.  */
  1341. void
  1342. tcp_pulloutofband(so, ti, m)
  1343.     struct socket *so;
  1344.     struct tcpiphdr *ti;
  1345.     register struct mbuf *m;
  1346. {
  1347.     int cnt = ti->ti_urp - 1;
  1348.     
  1349.     while (cnt >= 0) {
  1350.         if (m->m_len > cnt) {
  1351.             char *cp = mtod(m, caddr_t) + cnt;
  1352.             struct tcpcb *tp = sototcpcb(so);
  1353.  
  1354.             tp->t_iobc = *cp;
  1355.             tp->t_oobflags |= TCPOOB_HAVEDATA;
  1356.             bcopy(cp+1, cp, (unsigned)(m->m_len - cnt - 1));
  1357.             m->m_len--;
  1358.             return;
  1359.         }
  1360.         cnt -= m->m_len;
  1361.         m = m->m_next;
  1362.         if (m == 0)
  1363.             break;
  1364.     }
  1365.     panic("tcp_pulloutofband");
  1366. }
  1367.  
  1368. /*
  1369.  * Collect new round-trip time estimate
  1370.  * and update averages and current timeout.
  1371.  */
  1372. void
  1373. tcp_xmit_timer(tp)
  1374.     register struct tcpcb *tp;
  1375. {
  1376.     register short delta;
  1377.  
  1378.     tcpstat.tcps_rttupdated++;
  1379.     if (tp->t_srtt != 0) {
  1380.         /*
  1381.          * srtt is stored as fixed point with 3 bits after the
  1382.          * binary point (i.e., scaled by 8).  The following magic
  1383.          * is equivalent to the smoothing algorithm in rfc793 with
  1384.          * an alpha of .875 (srtt = rtt/8 + srtt*7/8 in fixed
  1385.          * point).  Adjust t_rtt to origin 0.
  1386.          */
  1387.         delta = tp->t_rtt - 1 - (tp->t_srtt >> TCP_RTT_SHIFT);
  1388.         if ((tp->t_srtt += delta) <= 0)
  1389.             tp->t_srtt = 1;
  1390.         /*
  1391.          * We accumulate a smoothed rtt variance (actually, a
  1392.          * smoothed mean difference), then set the retransmit
  1393.          * timer to smoothed rtt + 4 times the smoothed variance.
  1394.          * rttvar is stored as fixed point with 2 bits after the
  1395.          * binary point (scaled by 4).  The following is
  1396.          * equivalent to rfc793 smoothing with an alpha of .75
  1397.          * (rttvar = rttvar*3/4 + |delta| / 4).  This replaces
  1398.          * rfc793's wired-in beta.
  1399.          */
  1400.         if (delta < 0)
  1401.             delta = -delta;
  1402.         delta -= (tp->t_rttvar >> TCP_RTTVAR_SHIFT);
  1403.         if ((tp->t_rttvar += delta) <= 0)
  1404.             tp->t_rttvar = 1;
  1405.     } else {
  1406.         /* 
  1407.          * No rtt measurement yet - use the unsmoothed rtt.
  1408.          * Set the variance to half the rtt (so our first
  1409.          * retransmit happens at 2*rtt)
  1410.          */
  1411.         tp->t_srtt = tp->t_rtt << TCP_RTT_SHIFT;
  1412.         tp->t_rttvar = tp->t_rtt << (TCP_RTTVAR_SHIFT - 1);
  1413.     }
  1414.     tp->t_rtt = 0;
  1415.     tp->t_rxtshift = 0;
  1416.  
  1417.     /*
  1418.      * the retransmit should happen at rtt + 4 * rttvar.
  1419.      * Because of the way we do the smoothing, srtt and rttvar
  1420.      * will each average +1/2 tick of bias.  When we compute
  1421.      * the retransmit timer, we want 1/2 tick of rounding and
  1422.      * 1 extra tick because of +-1/2 tick uncertainty in the
  1423.      * firing of the timer.  The bias will give us exactly the
  1424.      * 1.5 tick we need.  But, because the bias is
  1425.      * statistical, we have to test that we don't drop below
  1426.      * the minimum feasible timer (which is 2 ticks).
  1427.      */
  1428.     TCPT_RANGESET(tp->t_rxtcur, TCP_REXMTVAL(tp),
  1429.         tp->t_rttmin, TCPTV_REXMTMAX);
  1430.     
  1431.     /*
  1432.      * We received an ack for a packet that wasn't retransmitted;
  1433.      * it is probably safe to discard any error indications we've
  1434.      * received recently.  This isn't quite right, but close enough
  1435.      * for now (a route might have failed after we sent a segment,
  1436.      * and the return path might not be symmetrical).
  1437.      */
  1438.     tp->t_softerror = 0;
  1439. }
  1440.  
  1441. /*
  1442.  * Determine a reasonable value for maxseg size.
  1443.  * If the route is known, check route for mtu.
  1444.  * If none, use an mss that can be handled on the outgoing
  1445.  * interface without forcing IP to fragment; if bigger than
  1446.  * an mbuf cluster (mbconf.mclbytes), round down to nearest multiple of mbconf.mclbytes
  1447.  * to utilize large mbufs.  If no route is found, route has no mtu,
  1448.  * or the destination isn't local, use a default, hopefully conservative
  1449.  * size (usually 512 or the default IP max size, but no more than the mtu
  1450.  * of the interface), as we can't discover anything about intervening
  1451.  * gateways or networks.  We also initialize the congestion/slow start
  1452.  * window to be a single segment if the destination isn't local.
  1453.  * While looking at the routing entry, we also initialize other path-dependent
  1454.  * parameters from pre-set or cached values in the routing entry.
  1455.  */
  1456.  
  1457. int
  1458. tcp_mss(tp, offer)
  1459.     register struct tcpcb *tp;
  1460.     u_short offer;
  1461. {
  1462.     struct route *ro;
  1463.     register struct rtentry *rt;
  1464.     struct ifnet *ifp;
  1465.     register int rtt, mss;
  1466.     u_long bufsize;
  1467.     struct inpcb *inp;
  1468.     struct socket *so;
  1469.     extern int tcp_mssdflt, tcp_rttdflt;
  1470.  
  1471.     inp = tp->t_inpcb;
  1472.     ro = &inp->inp_route;
  1473.  
  1474.     if ((rt = ro->ro_rt) == (struct rtentry *)0) {
  1475.         /* No route yet, so try to acquire one */
  1476.         if (inp->inp_faddr.s_addr != INADDR_ANY) {
  1477.             ro->ro_dst.sa_family = AF_INET;
  1478.             ro->ro_dst.sa_len = sizeof(ro->ro_dst);
  1479.             ((struct sockaddr_in *) &ro->ro_dst)->sin_addr =
  1480.                 inp->inp_faddr;
  1481.             rtalloc(ro);
  1482.         }
  1483.         if ((rt = ro->ro_rt) == (struct rtentry *)0)
  1484.             return (tcp_mssdflt);
  1485.     }
  1486.     ifp = rt->rt_ifp;
  1487.     so = inp->inp_socket;
  1488.  
  1489. #ifdef RTV_MTU    /* if route characteristics exist ... */
  1490.     /*
  1491.      * While we're here, check if there's an initial rtt
  1492.      * or rttvar.  Convert from the route-table units
  1493.      * to scaled multiples of the slow timeout timer.
  1494.      */
  1495.     if (tp->t_srtt == 0 && (rtt = rt->rt_rmx.rmx_rtt)) {
  1496.         if (rt->rt_rmx.rmx_locks & RTV_MTU)
  1497.             tp->t_rttmin = rtt / (RTM_RTTUNIT / PR_SLOWHZ);
  1498.         tp->t_srtt = rtt / (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTT_SCALE));
  1499.         if (rt->rt_rmx.rmx_rttvar)
  1500.             tp->t_rttvar = rt->rt_rmx.rmx_rttvar /
  1501.                 (RTM_RTTUNIT / (PR_SLOWHZ * TCP_RTTVAR_SCALE));
  1502.         else
  1503.             /* default variation is +- 1 rtt */
  1504.             tp->t_rttvar =
  1505.                 tp->t_srtt * TCP_RTTVAR_SCALE / TCP_RTT_SCALE;
  1506.         TCPT_RANGESET(tp->t_rxtcur,
  1507.             ((tp->t_srtt >> 2) + tp->t_rttvar) >> 1,
  1508.             tp->t_rttmin, TCPTV_REXMTMAX);
  1509.     }
  1510.     /*
  1511.      * if there's an mtu associated with the route, use it
  1512.      */
  1513.     if (rt->rt_rmx.rmx_mtu)
  1514.         mss = rt->rt_rmx.rmx_mtu - sizeof(struct tcpiphdr);
  1515.     else
  1516. #endif /* RTV_MTU */
  1517.     {
  1518.         mss = ifp->if_mtu - sizeof(struct tcpiphdr);
  1519.  
  1520.         if (mss > mbconf.mclbytes)
  1521.             mss = mss / mbconf.mclbytes * mbconf.mclbytes;
  1522.  
  1523.         if (!in_localaddr(inp->inp_faddr))
  1524.             mss = min(mss, tcp_mssdflt);
  1525.     }
  1526.     /*
  1527.      * The current mss, t_maxseg, is initialized to the default value.
  1528.      * If we compute a smaller value, reduce the current mss.
  1529.      * If we compute a larger value, return it for use in sending
  1530.      * a max seg size option, but don't store it for use
  1531.      * unless we received an offer at least that large from peer.
  1532.      * However, do not accept offers under 32 bytes.
  1533.      */
  1534.     if (offer)
  1535.         mss = min(mss, offer);
  1536.     mss = max(mss, 32);        /* sanity */
  1537.     if (mss < tp->t_maxseg || offer != 0) {
  1538.         /*
  1539.          * If there's a pipesize, change the socket buffer
  1540.          * to that size.  Make the socket buffers an integral
  1541.          * number of mss units; if the mss is larger than
  1542.          * the socket buffer, decrease the mss.
  1543.          */
  1544. #ifdef RTV_SPIPE
  1545.         if ((bufsize = rt->rt_rmx.rmx_sendpipe) == 0)
  1546. #endif
  1547.             bufsize = so->so_snd.sb_hiwat;
  1548.         if (bufsize < mss)
  1549.             mss = bufsize;
  1550.         else {
  1551.             bufsize = min(bufsize, SB_MAX) / mss * mss;
  1552.             (void) sbreserve(&so->so_snd, bufsize);
  1553.         }
  1554.         tp->t_maxseg = mss;
  1555.  
  1556. #ifdef RTV_RPIPE
  1557.         if ((bufsize = rt->rt_rmx.rmx_recvpipe) == 0)
  1558. #endif
  1559.             bufsize = so->so_rcv.sb_hiwat;
  1560.         if (bufsize > mss) {
  1561.             bufsize = min(bufsize, SB_MAX) / mss * mss;
  1562.             (void) sbreserve(&so->so_rcv, bufsize);
  1563.         }
  1564.     }
  1565.     tp->snd_cwnd = mss;
  1566.  
  1567. #ifdef RTV_SSTHRESH
  1568.     if (rt->rt_rmx.rmx_ssthresh) {
  1569.         /*
  1570.          * There's some sort of gateway or interface
  1571.          * buffer limit on the path.  Use this to set
  1572.          * the slow start threshhold, but set the
  1573.          * threshold to no less than 2*mss.
  1574.          */
  1575.         tp->snd_ssthresh = max(2 * mss, rt->rt_rmx.rmx_ssthresh);
  1576.     }
  1577. #endif /* RTV_MTU */
  1578.     return (mss);
  1579. }
  1580.